﻿// 0906train02.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
#include <limits>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
#include <bitset>

using namespace std;

/*
 VLAN是一种对局域网设备进行逻辑划分的技术，为了标识不同的VLAN，引入VLAN ID（1-4094之间的整数）的概念。
定义一个VLAN ID的资源池（下称VLAN资源池），资源池中连续的VLAN用开始VLAN - 结束VLAN表示；
不连续的用单个整数表示，所有的VLAN用英文逗号连接起来。
现在有一个VLAN资源池，业务需要从资源池中申请一个VLAN，
需要你输出从VLAN资源池中移除申请的VLAN后的资源池。

输入描述
第一行为字符串格式的VLAN资源池，
第二行为业务要申请的VLAN，VLAN的取值范围为[1，4094]之间的整数。

输出描述
从输入VLAN资源池中移除申请的VLAN后字符串格式的VLAN资源池，输出要求满足题目描述中的格式，
并且按照VLAN从小到大升序输出。

如果申请的VLAN不在原VLAN资源池内，输出原VLAN资源池升序排序后的字符串即可

输入
1-5
2
输出
1,3-5
原VLAN资源池中有VLAN1、2、3、4、5，从资源池中移除2后，剩下VLAN 1、3、4、5
按照题目描述格式并升序后的结果为1,3-5

输入
20-21,15,18,30,5-10
15
输出
5-10,18,20-21,30
原VLAN资源池中有VLAN 5、6、7、8、9、10、15、18、20、21、30，
从资源池中移除15后，资源池中剩下的VLAN为5、6、7、8、9、10、18、20、21、30，
按照题目描述格式并升序后的结果为5-10,18,20-21,30。
 */
class Solution01
{
public:
    vector<int>getMapVec(string&num_str)
    {
        vector<int>map_vec;
        if (num_str.find('-')==string::npos)
        {
            int num = stoi(num_str);
            if (num==target_num)
            {
                target_str = num_str;
            }

            map_vec.push_back(num);
            return map_vec;
        }

        int split = num_str.find('-');
        string start_str = num_str.substr(0, split);
        int start_num = stoi(start_str);
        string end_str = num_str.substr(split + 1);
        int end_num = stoi(end_str);

        for (int i=start_num; i<=end_num;i++)
        {
            if (i==target_num)
            {
                target_str = num_str;
            }
            map_vec.push_back(i);
        }
        return map_vec;
    }
    vector<pair<string, int>>getNewStr(string num_str, vector<int>&num_vec)
    {
        //含-，破开
        //是否开头结尾
        vector<pair<string, int>>result;
        if (target_num == num_vec[0])
        {
            if (num_vec.size()==2)
            {
                string new_str = to_string(num_vec[1]);
                result.push_back(make_pair(new_str, num_vec[1]));
                return result;
            }
            string new_str;
            new_str += to_string(num_vec[1]);
            new_str += '-';
            new_str += to_string(num_vec[num_vec.size() - 1]);
            result.push_back(make_pair(new_str, num_vec[1]));
            return result;
        }

        if (target_num == num_vec[num_vec.size() - 1])
        {
            if (num_vec.size() == 2)
            {
                string new_str = to_string(num_vec[0]);
                result.push_back(make_pair(new_str, num_vec[0]));
                return result;
            }
            string new_str;
            new_str += to_string(num_vec[0]);
            new_str += '-';
            new_str += to_string(num_vec[num_vec.size() - 2]);
            result.push_back(make_pair(new_str, num_vec[0]));
            return result;
        }

        //既不等于开头，也不等于结尾，破开
        vector<int>start_vec;
        vector<int>end_vec;
        bool is_end = false;
        for (int i=0; i<num_vec.size(); i++)
        {
            if (!is_end && num_vec[i] != target_num)
            {
                start_vec.push_back(num_vec[i]);
            }

	        if (num_vec[i]==target_num)
	        {
                is_end = true;
                continue;
	        }
            if (is_end)
            {
                end_vec.push_back(num_vec[i]);
            }
        }
        string start_str;
        //破成2个数
        if (start_vec.size()==1)
        {
            start_str += to_string(start_vec[0]);
        }
        else
        {
            start_str += to_string(start_vec[0]);
            start_str += '-';
            start_str += to_string(start_vec[start_vec.size() - 1]);
        }
        result.push_back(make_pair(start_str, start_vec[0]));

        string end_str;
        if (end_vec.size()==1)
        {
            end_str += to_string(end_vec[0]);
        }
        else
        {
            end_str += to_string(end_vec[0]);
            end_str += '-';
            end_str += to_string(end_vec[end_vec.size() - 1]);
        }
        result.push_back(make_pair(end_str, end_vec[0]));
        return result;
	    //getNewStr
    }

    Solution01(vector<string>&str_vec, int erase_num)
    {
        target_num = erase_num;
        //需要一个map，存i-j这种格式的数
        unordered_map<string, vector<int>>num_str_map;

        //更新target_str
        for (auto&str:str_vec)
        {
            vector<int>map_vec = getMapVec(str);
            num_str_map[str] = map_vec;
        }

        //处理target_str
        vector<pair<string, int>>sort_vec;
        for (auto&map_item:num_str_map)
        {
            string num_str = map_item.first;
            vector<int>num_vec = map_item.second;
            if (num_str==target_str)
            {
                if (num_str.find('-')==string::npos)
                {
	                //不含-，直接去掉，不进sort
                    continue;
                }

                vector<pair<string, int>>new_vec = getNewStr(num_str, num_vec);
                for (auto&item:new_vec)
                {
                    sort_vec.push_back(item);
                }

                continue;
            }
            //不为目标串，不用处理
            sort_vec.push_back(make_pair(num_str, num_vec[0]));
        }

        sort(sort_vec.begin(), sort_vec.end(), [](pair<string, int>& a, pair<string, int>& b)
            {
                return a.second < b.second;
            });

        for (int i=0; i<sort_vec.size(); i++)
        {
            cout << sort_vec[i].first;
            if (i!=sort_vec.size()-1)
            {
                cout << ',';
            }
        }

        //Solution01
    }
private:
    int target_num = 0;
    string target_str;
};


/*
给定两个字符串，分别为字符串A与字符串B。
例如A字符串为ABCABBA，B字符串为CBABAC，可以得到下图m*n的二维数组，
定义原点为(0,0)，终点为(m,n)，水平与垂直的每一条边距离为1，映射成坐标系如下图

从原点(0,0)到(0,A)为水平边，距离为1，从(0,A)到(A,C)为垂直边，距离为1；
假设两个字符串同一位置的两个字符相同则可以作一个斜边，
如(A,C)到(B,B)最短距离为斜边，距离同样为1。出所有的斜边如下图，
(0,0)到(B,B)的距离为 1个水平边+ 1个垂直边+ 1个斜边=3

输入描述
空格分割的两个字符串A与字符串B，字符串不为空串，字符格式满足正则规则:[A-Z]，字符串长度<10000

输出描述
原点到终点的最短距离

输入
ABC ABC
输出
3

输入
ABCABBA CBABAC
输出
9
 */
class Solution02
{
public:
    void getMatrix(string& col_text, string& row_text)
    {
        vector<vector<pair<char, char>>>matrix(row_size, vector<pair<char, char>>(col_size));

        matrix[0][0] = make_pair('0', '0');
        for (int c=1; c<col_size; c++)
        {
            matrix[0][c] = make_pair('0', col_text[c-1]);
        }
        for (int r=1; r<row_size; r++)
        {
            matrix[r][0] = make_pair(row_text[r-1], '0');
        }

        for (int r=1; r<row_size; r++)
        {
	        for (int c=1;c<col_size; c++)
	        {
                matrix[r][c] = make_pair(row_text[r-1], col_text[c-1]);
	        }
        }
        matrix_ = matrix;
        //getMatrix
    }

    Solution02(string&col_text, string&row_text)
    {
        row_size = row_text.size()+1;
        col_size = col_text.size()+1;

        getMatrix(col_text, row_text);
        vector<vector<int>>dynamic_vec(row_size, vector<int>(col_size));

        dynamic_vec[0][0] = 0;
        for (int c=1; c< col_size; c++)
        {
            dynamic_vec[0][c] += dynamic_vec[0][c - 1]+1;
        }

        for (int r=1; r<row_size; r++)
        {
            dynamic_vec[r][0] += dynamic_vec[r - 1][0] + 1;
        }

        for (int r=1; r<row_size; r++)
        {
	        for (int c=1; c<col_size; c++)
	        {
                pair<char, char>curr_pair = matrix_[r][c];
                if (curr_pair.first==curr_pair.second)
                {
                    dynamic_vec[r][c] = dynamic_vec[r - 1][c - 1] + 1;
                }
                else
                {
                    int min_prev = min(dynamic_vec[r - 1][c], dynamic_vec[r][c - 1]);
                    dynamic_vec[r][c] = min_prev + 1;
                }

	        }
        }
        cout << dynamic_vec[row_text.size()][col_text.size()];
        //Solution02
    }
private:
    int row_size=0, col_size=0;
    vector<vector<pair<char, char>>>matrix_;
};


class Solution03
{
public:
    Solution03(vector<int>&num_vec)
    {
        int xorsum = num_vec[0];

        for (int i=1; i<num_vec.size(); i++)
        {
            xorsum = xorsum ^ num_vec[i];
        }

        int total_sum = 0;
        int min_num = INT_MAX;
        for (auto&num:num_vec)
        {
            total_sum += num;
            min_num = min(min_num, num);
        }

        if (xorsum==0)
        {
            cout << total_sum - min_num;
        }
        else
        {
            cout << -1;
        }

    }
};

int main()
{
	{
        int v_size;
        cin >> v_size;

        vector<int>num_vec(v_size);

        for (int i=0; i<v_size; i++)
        {
            cin >> num_vec[i];
        }

        Solution03 solu(num_vec);

        return 0;
	}
	{
        string col_text, row_text;
        cin >> col_text >> row_text;

        Solution02 solu(col_text, row_text);
        return 0;
	}
    //1-5
    //2
    //20-21,15,18,30,5-10
    vector<string>num_str_vec;
    string input;
    getline(cin, input);
    stringstream oh_sstream(input);
    string token;
    while (getline(oh_sstream,token,','))
    {
        num_str_vec.push_back(token);
    }
    int erase_num;
    cin >> erase_num;
    Solution01 solu(num_str_vec, erase_num);
    
}

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件
